{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PaddleCamp - 第二期\n",
    "\n",
    "## 第一周 - 作业参考答案"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### 第一次作业\n",
    "\n",
    "该部分作业共 **1** 部分：\n",
    "\n",
    "----\n",
    "\n",
    "* 客观题**参考答案**：\n",
    "\n",
    "1.\t人工神经元内部运算包含哪两个部分：\n",
    "A.非线性变换和激活变换  **B.线性变换和非线性变换**  C.向量变换和标量变换  D.化学变换和电变换\n",
    "\n",
    "2.\t人工神经网络与生物神经网络的关系：\n",
    "A.完全拷贝  B.一点点关系都没有  **C.人工神经网络受生物神经网络启发**  D. 同一事物的两个名称\n",
    "\n",
    "3.\t深度学习系统训练过程通常需要输入：\n",
    "A.特征值  B.标签  **C.特征值和标签**  D. 预测值\n",
    "\n",
    "\n",
    "4.\t“每个神经元都和下一层的所有神经元相连”的神经网络是：\n",
    "A.卷积神经网络  B.大规模神经网络  C.循环神经网络  **D. 全连接神经网络**\n",
    "\n",
    "\n",
    "5.\t深度神经网络的运行过程是由三个算法依次运行组成，下面不属于这三个算法中的是：\n",
    "**A.归一化**  B.正向传播  C.反向传播  D.梯度下降\n",
    "\n",
    "6.\t下面不是超参数的是：\n",
    "**A.权重和偏置**  B.学习率  C.mini-batch的大小  D.网络结构\n",
    "\n",
    "7.\t不属于常见激活：\n",
    "A.sigmoid  B.Relu  **C.NMS**  D.Tanh\n",
    "\n",
    "8.\t属于常见损失函数：\n",
    "A.计算预测值函数  B.求偏导数函数  **C.均方误差损失函数**  D.更新参数函数\n",
    "\n",
    "9.\t关于梯度下降算法描述正确的是：\n",
    "**A.梯度下降算法就是不断的更新 w和b 的值**  \n",
    "B.梯度下降算法就是不断的更新 w和b 的导数值  \n",
    "C.梯度下降算法就是不断寻找损失函数的最大值\n",
    "D.梯度下降算法就是不断更新学习率\n",
    "\n",
    "10.\t关于学习率的描述正确的是：\n",
    "A.学习率和 w、b 一样是参数，是系统自己学习得到的  \n",
    "B.学习率越大系统运行速度越快  \n",
    "C.学习率越小系统一定精度越高\n",
    "**D.学习率的大小是根据不同场景程序员自己设定的，不宜太大或者太小**\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### 第二次作业\n",
    "\n",
    "该部分作业共 **2** 部分：\n",
    "\n",
    "-----\n",
    "\n",
    "* 客观题**参考答案**：\n",
    "\n",
    "1.\t下面不属于深度学习开发框架的是：\n",
    "A.TensorFlow  B.Pytorch  **C.AI-Studio**  D.PaddlePaddle \n",
    "\n",
    "2.\t关于PaddlePaddle描述不正确的是：\n",
    "A.PaddlePaddle 是开源的  \n",
    "B.PaddlePaddle 是自主开发的  \n",
    "**C.PaddlePaddle 仅仅是对其他框架做了包装**  \n",
    "D.PaddlePaddle 是深度学习开发框架 \n",
    "\n",
    "3.\t以下任务不适合使用 PaddlePaddle 的是：\n",
    "**A.5G网络通信任务**  B.目标检测任务  C.情感分类任务  D. 推荐系统任务\n",
    "\n",
    "\n",
    "4.\t以下不属于 PaddlePaddle 特点的是：\n",
    "A.在github上代码开源  B.支持分布式系统  C.支持多卡并行运行  **D.不支持移动端设备** \n",
    "\n",
    "5.\tPaddlePaddle代码不包括以下哪个部分：\n",
    "**A.从网上爬取数据**  B.参数初始化  C.训练过程  D.预测过程\n",
    "\n",
    "6.\t双层 For 循环的外层循环的作用是：\n",
    "**A.决定训练的轮数**  B.设置学习率  C.决定mini-batch的大小  D.决定网络结构\n",
    "\n",
    "7.\t以下代码用来创建一个数据输入层的是：\n",
    "**A.  x = fluid.layers.data(name='x', shape=[8], dtype='float32')**\n",
    "B.  y_predict = fluid.layers.fc(input=x, size=1, act=None)\n",
    "C.  loss = fluid.layers.square_error_cost(input=y_predict, label=y)\n",
    "D.  exe.run( fluid.default_startup_program() )\n",
    "\n",
    "8.\t关于 AI-Studio的描述正确的是：\n",
    "A. AI-Studio是一个深度学习开发框架  \n",
    "B. AI-Studio需要在本地电脑安装客户端  \n",
    "C. AI-Studio不支持GPU运行  \n",
    "**D. AI-Studio是在线编程平台**\n",
    "\n",
    "9.\t程序员拿到数据集后通常要把数据集进行划分，划分好的数据集用来做训练与预测，那么一般划分方式为：\n",
    "A.划分为正例与负例  \n",
    "**B.划分为训练集与预测集**  \n",
    "C.划分为可用数据与不可用数据 \n",
    "D.划分为大数据集与小数据集 \n",
    "\n",
    "10.\t以下不是做数据归一化的原因的是：\n",
    "A.过大或过小的数值范围会导致计算时的浮点上溢或下溢  \n",
    "B.去掉不同维度的数据因为数据取值范围大小不同而对系统产生的影响  \n",
    "C.某机器学习的技巧的前提假设就是数据已经经历过了数据归一化 \n",
    "**D.输入的数据必须符合均值为0，方差为1**\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 代码填空题**参考答案**：\n",
    "\n",
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Archive:  data/data9911/data_images.zip\r\n",
      "  inflating: data_images/datasets/data.txt  \r\n",
      "  inflating: data_images/images/.png  \r\n",
      "  inflating: data_images/images/FC.png  \r\n",
      "  inflating: data_images/images/ML_process.png  \r\n",
      "  inflating: data_images/images/gradient_descent.png  \r\n",
      "  inflating: data_images/images/plt.png  \r\n",
      "  inflating: data_images/images/result.png  \r\n"
     ]
    }
   ],
   "source": [
    "#因为本次实验除了代码还有许多知识点讲解。\r\n",
    "#知识点是以markdown形式展现的，含有许多图片。\r\n",
    "#运行完这条命令，并刷新一下本页面，本实验中的图片就可以展现出来了。\r\n",
    "#这条命令只需要运行一遍就可以了。\r\n",
    "!DATA_PATH=data/data9911/ && NEW_NAME=$(find -name *[0-9].ipynb) && NEW_NAME=${NEW_NAME%.*} && NEW_NAME=${NEW_NAME#./} && unzip -o ${DATA_PATH}data_images.zip  && cp -rf data_images/. ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the raw area : 199.96\n",
      "normalization: 0.6587568635148239\n"
     ]
    }
   ],
   "source": [
    "\r\n",
    "from __future__ import print_function\r\n",
    "import numpy as np\r\n",
    "import matplotlib.pyplot as plt\r\n",
    "import pandas as pd\r\n",
    "import paddle\r\n",
    "import paddle.fluid as fluid\r\n",
    "\r\n",
    "import math\r\n",
    "import sys\r\n",
    "\r\n",
    "# coding = utf-8 #\r\n",
    "global x_raw,train_data,test_data\r\n",
    "data = np.loadtxt('./datasets/data.txt',delimiter = ',')\r\n",
    "x_raw = data.T[0].copy() \r\n",
    "\r\n",
    "#axis=0,表示按列计算\r\n",
    "#data.shape[0]表示data中一共有多少列\r\n",
    "maximums, minimums, avgs = data.max(axis=0), data.min(axis=0), data.sum(axis=0)/data.shape[0]\r\n",
    "print(\"the raw area :\",data[:,0].max(axis = 0))\r\n",
    "\r\n",
    "#归一化，data[:,i]表示第i列的元素\r\n",
    "\r\n",
    "### START CODE HERE ### (≈ 3 lines of code)\r\n",
    "\r\n",
    "feature_num = 2\r\n",
    "for i in range(feature_num-1):\r\n",
    "    data[:,i] = (data[:,i]-avgs[i])/(maximums[i]-minimums[i])\r\n",
    "    \r\n",
    "### END CODE HERE ###\r\n",
    "\r\n",
    "print('normalization:',data[:,0].max(axis = 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "870\n",
      "696\n"
     ]
    }
   ],
   "source": [
    "ratio = 0.8\r\n",
    "offset = int(data.shape[0]*ratio)\r\n",
    "\r\n",
    "### START CODE HERE ### (≈ 2 lines of code)\r\n",
    "\r\n",
    "train_data = data[:offset].copy()\r\n",
    "test_data = data[offset:].copy()\r\n",
    "\r\n",
    "### END CODE HERE ###\r\n",
    "\r\n",
    "print(len(data))\r\n",
    "print(len(train_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test_array for read_data:\n",
      "([10], [100])\n",
      "([20], [200])\n"
     ]
    }
   ],
   "source": [
    "def read_data(data_set):\r\n",
    "    \"\"\"\r\n",
    "    一个reader\r\n",
    "    Args：\r\n",
    "        data_set -- 要获取的数据集\r\n",
    "    Return：\r\n",
    "        reader -- 用于获取训练集及其标签的生成器generator\r\n",
    "    \"\"\"\r\n",
    "    def reader():\r\n",
    "        \"\"\"\r\n",
    "        一个reader\r\n",
    "        Args：\r\n",
    "        Return：\r\n",
    "            data[:-1],data[-1:] --使用yield返回生成器\r\n",
    "                data[:-1]表示前n-1个元素，也就是训练数据，\r\n",
    "                data[-1:]表示最后一个元素，也就是对应的标签\r\n",
    "        \"\"\"\r\n",
    "        for data in data_set:\r\n",
    "            yield data[:-1],data[-1:]\r\n",
    "    return reader\r\n",
    "    \r\n",
    "    \r\n",
    "#测试reader\r\n",
    "test_array = ([10,100],[20,200])\r\n",
    "print(\"test_array for read_data:\")\r\n",
    "for value in read_data(test_array)():\r\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "BATCH_SIZE = 1000\r\n",
    "\r\n",
    "# 设置训练reader\r\n",
    "train_reader = paddle.batch(\r\n",
    "    paddle.reader.shuffle(\r\n",
    "        read_data(train_data), \r\n",
    "        buf_size=700),\r\n",
    "    batch_size=BATCH_SIZE)\r\n",
    "\r\n",
    "#设置测试 reader\r\n",
    "test_reader = paddle.batch(\r\n",
    "    paddle.reader.shuffle(\r\n",
    "        read_data(test_data), \r\n",
    "        buf_size=500),\r\n",
    "    batch_size=BATCH_SIZE)\r\n",
    "    \r\n",
    "\r\n",
    "#使用CPU或者GPU训练\r\n",
    "use_cuda = False\r\n",
    "place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "optimizer is ready\n"
     ]
    }
   ],
   "source": [
    "# 输入层，fluid.layers.data表示数据层,name=’x’：名称为x,输出类型为tensor\r\n",
    "# shape=[1]:数据为1维向量\r\n",
    "# dtype='float32'：数据类型为float32\r\n",
    "### START CODE HERE ### (≈ 1 lines of code)\r\n",
    "x = fluid.layers.data(name='x', shape=[1], dtype='float32')\r\n",
    "### END CODE HERE ###\r\n",
    "\r\n",
    "# 标签数据，fluid.layers.data表示数据层,name=’y’：名称为y,输出类型为tensor\r\n",
    "# shape=[1]:数据为1维向量\r\n",
    "### START CODE HERE ### (≈ 1 lines of code)\r\n",
    "y = fluid.layers.data(name='y', shape=[1], dtype='float32')\r\n",
    "### END CODE HERE ###\r\n",
    "\r\n",
    "# 输出层，fluid.layers.fc表示全连接层，input=x: 该层输入数据为x\r\n",
    "# size=1：神经元个数，act=None：激活函数为线性函数\r\n",
    "y_predict = fluid.layers.fc(input=x, size=1, act=None, bias_attr=True)\r\n",
    "\r\n",
    "# 定义损失函数为均方差损失函数,并且求平均损失，返回值名称为avg_loss\r\n",
    "### START CODE HERE ### (≈ 2 lines of code)\r\n",
    "loss = fluid.layers.square_error_cost(input=y_predict, label=y)\r\n",
    "avg_loss = fluid.layers.mean(loss)\r\n",
    "### END CODE HERE ###\r\n",
    "\r\n",
    "# 定义执行器(参数随机初始化):\r\n",
    "exe = fluid.Executor(place)\r\n",
    "\r\n",
    "# 配置训练程序:\r\n",
    "main_program = fluid.default_main_program() # 获取默认/全局主函数\r\n",
    "startup_program = fluid.default_startup_program() # 获取默认/全局启动程序\r\n",
    "\r\n",
    "#克隆main_program得到test_program\r\n",
    "#有些operator在训练和测试之间的操作是不同的，例如batch_norm，使用参数for_test来区分该程序是用来训练还是用来测试\r\n",
    "#该api不会删除任何操作符,请在backward和optimization之前使用\r\n",
    "test_program = main_program.clone(for_test=True)\r\n",
    "\r\n",
    "# 创建optimizer，更多优化算子可以参考 fluid.optimizer()\r\n",
    "learning_rate = 0.001\r\n",
    "sgd_optimizer = fluid.optimizer.SGD(learning_rate)\r\n",
    "# sgd_optimizer = fluid.optimizer.Adam(learning_rate)\r\n",
    "sgd_optimizer.minimize(avg_loss)\r\n",
    "print(\"optimizer is ready\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test cost, Step 0, Cost 449946.468750\n",
      "Test cost, Step 100, Cost 326451.968750\n",
      "Test cost, Step 200, Cost 243213.375000\n",
      "Test cost, Step 300, Cost 186993.062500\n",
      "Test cost, Step 400, Cost 148912.781250\n",
      "Test cost, Step 500, Cost 123017.054688\n",
      "Test cost, Step 600, Cost 105310.296875\n",
      "Test cost, Step 700, Cost 93110.945312\n",
      "Test cost, Step 800, Cost 84618.828125\n",
      "Test cost, Step 900, Cost 78625.203125\n",
      "Test cost, Step 1000, Cost 74317.867188\n",
      "Test cost, Step 1100, Cost 71151.031250\n",
      "Test cost, Step 1300, Cost 66890.203125\n",
      "Test cost, Step 1400, Cost 65382.695312\n",
      "Test cost, Step 1500, Cost 64122.765625\n",
      "Test cost, Step 1600, Cost 63034.613281\n",
      "Test cost, Step 1700, Cost 62067.035156\n",
      "Test cost, Step 1800, Cost 61185.308594\n",
      "Test cost, Step 1900, Cost 60365.886719\n",
      "Test cost, Step 2000, Cost 59592.695312\n",
      "Test cost, Step 2100, Cost 58854.804688\n",
      "Test cost, Step 2200, Cost 58144.671875\n",
      "Test cost, Step 2300, Cost 57457.074219\n",
      "Test cost, Step 2400, Cost 56788.406250\n",
      "Test cost, Step 2500, Cost 56136.160156\n",
      "Test cost, Step 2600, Cost 55498.496094\n",
      "Test cost, Step 2700, Cost 54874.136719\n",
      "Test cost, Step 2800, Cost 54262.125000\n",
      "Test cost, Step 2900, Cost 53661.734375\n",
      "Test cost, Step 3000, Cost 53072.429688\n",
      "Test cost, Step 3100, Cost 52493.789062\n",
      "Test cost, Step 3200, Cost 51925.406250\n",
      "Test cost, Step 3300, Cost 51367.050781\n",
      "Test cost, Step 3400, Cost 50818.425781\n",
      "Test cost, Step 3500, Cost 50279.308594\n",
      "Test cost, Step 3600, Cost 49749.515625\n",
      "Test cost, Step 3700, Cost 49228.843750\n",
      "Test cost, Step 3800, Cost 48717.125000\n",
      "Test cost, Step 3900, Cost 48214.183594\n",
      "Test cost, Step 4000, Cost 47719.863281\n",
      "Test cost, Step 4100, Cost 47234.015625\n",
      "Test cost, Step 4200, Cost 46756.484375\n",
      "Test cost, Step 4300, Cost 46287.125000\n",
      "Test cost, Step 4400, Cost 45825.816406\n",
      "Test cost, Step 4500, Cost 45372.398438\n",
      "Test cost, Step 4600, Cost 44926.746094\n",
      "Test cost, Step 4700, Cost 44488.726562\n",
      "Test cost, Step 4800, Cost 44058.199219\n",
      "Test cost, Step 4900, Cost 43635.058594\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# For training test cost\r\n",
    "def train_test(executor, program, reader, feeder, fetch_list):\r\n",
    "    accumulated = 1 * [0]\r\n",
    "    count = 0\r\n",
    "    for data_test in reader():\r\n",
    "        outs = executor.run(\r\n",
    "            program=program, feed=feeder.feed(data_test), fetch_list=fetch_list)\r\n",
    "        accumulated = [x_c[0] + x_c[1][0] for x_c in zip(accumulated, outs)]  # 累加测试过程中的损失值\r\n",
    "        count += 1 # 累加测试集中的样本数量\r\n",
    "    return [x_d / count for x_d in accumulated] # 计算平均损失\r\n",
    "\r\n",
    "# 定义模型保存路径：\r\n",
    "#params_dirname用于定义模型保存路径。\r\n",
    "params_dirname = \"easy_fit_a_line.inference.model\"\r\n",
    "\r\n",
    "#用于画图展示训练cost\r\n",
    "from paddle.utils.plot import Ploter\r\n",
    "train_prompt = \"Train cost\"\r\n",
    "test_prompt = \"Test cost\"\r\n",
    "plot_prompt = Ploter(train_prompt, test_prompt)\r\n",
    "step = 0\r\n",
    "\r\n",
    "# 训练主循环\r\n",
    "feeder = fluid.DataFeeder(place=place, feed_list=[x, y])\r\n",
    "exe.run(startup_program)\r\n",
    "\r\n",
    "exe_test = fluid.Executor(place)\r\n",
    "\r\n",
    "#num_epochs=100表示迭代训练100次后停止训练。\r\n",
    "num_epochs = 5000\r\n",
    "\r\n",
    "for pass_id in range(num_epochs):\r\n",
    "    for data_train in train_reader():\r\n",
    "        avg_loss_value, = exe.run(main_program,\r\n",
    "                                  feed=feeder.feed(data_train),\r\n",
    "                                  fetch_list=[avg_loss])\r\n",
    "        if step % 10 == 0:  # 每10个批次记录并输出一下训练损失\r\n",
    "            plot_prompt.append(train_prompt, step, avg_loss_value[0])\r\n",
    "            plot_prompt.plot()\r\n",
    "            #print(\"%s, Step %d, Cost %f\" %(train_prompt, step, avg_loss_value[0]))\r\n",
    "        if step % 100 == 0:  # 每100批次记录并输出一下测试损失\r\n",
    "            test_metics = train_test(executor=exe_test,\r\n",
    "                                     program=test_program,\r\n",
    "                                     reader=test_reader,\r\n",
    "                                     fetch_list=[avg_loss.name],\r\n",
    "                                     feeder=feeder)\r\n",
    "            plot_prompt.append(test_prompt, step, test_metics[0])\r\n",
    "            plot_prompt.plot()\r\n",
    "            print(\"%s, Step %d, Cost %f\" %(test_prompt, step, test_metics[0]))\r\n",
    "    \r\n",
    "            if test_metics[0] < 10.0: # 如果准确率达到要求，则停止训练\r\n",
    "                break\r\n",
    "\r\n",
    "        step += 1\r\n",
    "\r\n",
    "        if math.isnan(float(avg_loss_value[0])):\r\n",
    "            sys.exit(\"got NaN loss, training failed.\")\r\n",
    "\r\n",
    "        #保存训练参数到之前给定的路径中\r\n",
    "        if params_dirname is not None:\r\n",
    "            fluid.io.save_inference_model(params_dirname, ['x'], [y_predict], exe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor_x is : [[0.9959587]\n",
      " [0.2255538]]\n",
      "the area is: [[253.86844]\n",
      " [130.70383]]\n",
      "infer results:  [[1744.8499 ]\n",
      " [ 868.53705]]\n"
     ]
    }
   ],
   "source": [
    "# 预测\r\n",
    "infer_exe = fluid.Executor(place)\r\n",
    "inference_scope = fluid.core.Scope()\r\n",
    "\r\n",
    "with fluid.scope_guard(inference_scope):\r\n",
    "    [inference_program, feed_target_names, fetch_targets\r\n",
    "     ] = fluid.io.load_inference_model(params_dirname, infer_exe) # 载入预训练模型\r\n",
    "\r\n",
    "\r\n",
    "    batch_size = 2\r\n",
    "    tensor_x = np.random.uniform(0, 1, [batch_size, 1]).astype(\"float32\")\r\n",
    "    \r\n",
    "    print(\"tensor_x is :\" ,tensor_x )\r\n",
    "    results = infer_exe.run(\r\n",
    "        inference_program,\r\n",
    "        feed={feed_target_names[0]: tensor_x},\r\n",
    "        fetch_list=fetch_targets) # 进行预测\r\n",
    "    raw_x = tensor_x*(maximums[0]-minimums[0])+avgs[i]\r\n",
    "    print(\"the area is:\",raw_x)\r\n",
    "    print(\"infer results: \", results[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.114972 -61.416992\n"
     ]
    }
   ],
   "source": [
    "# 已知两点求直线方程\r\n",
    "a = (results[0][0][0] - results[0][1][0]) / (raw_x[0][0]-raw_x[1][0])\r\n",
    "b = (results[0][0][0] - a * raw_x[0][0])\r\n",
    "\r\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制图形\r\n",
    "import numpy as np\r\n",
    "import matplotlib.pyplot as plt\r\n",
    "\r\n",
    "def plot_data(data):\r\n",
    "    x = data[:,0]\r\n",
    "    y = data[:,1]\r\n",
    "    y_predict = x*a + b\r\n",
    "    plt.scatter(x,y,marker='.',c='r',label='True')\r\n",
    "    plt.title('House Price Distributions')\r\n",
    "    plt.xlabel('House Area ')\r\n",
    "    plt.ylabel('House Price ')\r\n",
    "    plt.xlim(0,250)\r\n",
    "    plt.ylim(0,2500)\r\n",
    "    predict = plt.plot(x,y_predict,label='Predict')\r\n",
    "    plt.legend(loc='upper left')\r\n",
    "    plt.savefig('result1.png')\r\n",
    "    plt.show()\r\n",
    "\r\n",
    "### START CODE HERE ### (≈ 2 lines of code)    \r\n",
    "data = np.loadtxt('./datasets/data.txt',delimiter = ',')\r\n",
    "plot_data(data)\r\n",
    "### START CODE HERE ### (≈ 2 lines of code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PaddlePaddle 1.5.0 (Python 3.5)",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
